/******************************************
Probando_Arbol_2_3.java
Universidad del Valle de Guatemala
Algoritmos y Estructura de Datos
Autor:
    Martín Guzmán
Fecha: 30 de septiembre de 2009
Descripción: 
*******************************************/

import java.lang.reflect.Array;
import java.util.Scanner;

import java.util.LinkedList;
import java.util.Random;

public class Probando_Arbol_2_3 {
    private static int hacer;
    private static int opciones_del_menu = 0;

    private static Scanner scan = new Scanner(System.in);

    //***********************
    private static Conjunto A;
    private static Conjunto B;
    private static Conjunto C;
    //***********************
    

    //método main donde empieza la ejecución del programa
    public static void main(String args[])
    {
        System.out.println("\n********************************************************\n");
        System.out.println("     Bienvenido al sistema operaciones con conjuntos\n");
        System.out.println("*********************************************************");

        A = new Conjunto<Integer>();
        B = new Conjunto<Integer>();

        //ciclo para repetir hasta que quiera salir del programa
        do
        {
            Menu();
        } while (hacer!=opciones_del_menu);//hasta que precione salir
        System.out.println("\n\n¡Gracias por utilizar el programa!");
    }

    //método que despliega el menú para realizar la acción del usuario ****************************
    public static void Menu(){
        do //ciclo hasta que ingrese bien una acción a realizar
        {
            opciones_del_menu=0;

            System.out.println("\n\t**** Menu Principal del sistema de operaciones entre conjuntos ****\n");
            System.out.println("1- Ingresar conjuntos");
            opciones_del_menu++;
            System.out.println("2- Ver conjunto A");
            opciones_del_menu++;
            System.out.println("3- Ver conjunto B");
            opciones_del_menu++;
            System.out.println("4- Agregar/Quitar elemento a conjunto A");
            opciones_del_menu++;
            System.out.println("5- Agregar/Quitar elemento a conjunto B");
            opciones_del_menu++;
            System.out.println("6- Ver A Unión B (unión de los conjuntos A y B)");
            opciones_del_menu++;
            System.out.println("7- Ver A Intersección B (intersección de los conjuntos A y B)");
            opciones_del_menu++;
            System.out.println("8- Salir del Programa");
            opciones_del_menu++;
            System.out.print("\t¿Qué desea hacer?\tMarque el número: ");
            //despliega mensaje de error si no escoje una opcion del menu principal
            try{
                hacer=scan.nextInt();
            }
            catch(Exception exp){ //para prevenir el ingreso de algún caracter diferente a número
                System.out.println("¡Error accion no válida!\n");
                hacer=-1;
            }
            scan.nextLine();
            if ((hacer<1 || hacer>opciones_del_menu) &&(hacer!=-1))
                System.out.println("¡Error accion fuera de las opciones!\n");

        } while (hacer<1 || hacer>opciones_del_menu);
        System.out.println("\n*************************************************************\n");


        String imprimir;//para imprimir en pantalla los valores de los conjuntos
        //para realizar la accion marcada arriba
        switch (hacer)
        {
            case 1://  ********* 1- Cambiar conjuntos ************************************************
                //System.out.println("Cambiar conjuntos");

                System.out.println("Siga el siguiente ejemplo para ingreso de elementos:\n\t1 2 3 4 = {1,2,3,4}");

                System.out.println("\nIngrese los elementos del conjunto A");
                String texto_A = scan.nextLine();
                //quitar los espacios en blanco de más
                while(true){
                    if(texto_A.contains("  ")==true){
                        texto_A=texto_A.replaceAll("  "," ");
                    }
                    else
                        break;
                }
                //quitar los espacios en blanco al inicio
                while(true){
                    if(texto_A.startsWith(" ")==true){
                        texto_A=texto_A.substring(1);
                    }
                    else
                        break;
                }
                //quitar los espacios en blanco al final
                while(true){
                    if(texto_A.endsWith(" ")==true){
                        texto_A=texto_A.substring(0,texto_A.length()-1);
                    }
                    else
                        break;
                }

                String[] temp_arreglo_A = texto_A.split(" ");

                LinkedList<Integer> temp_lista_A = new LinkedList<Integer>();
                try{
                    for(int i=0;i<temp_arreglo_A.length;i++){
                        temp_lista_A.add(Integer.parseInt(temp_arreglo_A[i]));
                    }
                    ordenar_lista(temp_lista_A);
                }catch(Exception exp){
                    System.out.println("Lo siento.. ingresó mal el conjunto A");
                    hacer=-1;
                    break;
                }
                
                //Quitar repetidos
                for(int i=0;i<temp_lista_A.size()-1;i++){
                    if(temp_lista_A.get(i).equals(temp_lista_A.get(i+1))){
                        temp_lista_A.remove(i--);
                    }
                }


                System.out.println("\nIngrese los elementos del conjunto B");
                String texto_B = scan.nextLine();

                //quitar los espacios en blanco de más
                while(true){
                    if(texto_B.contains("  ")==true){
                        texto_B=texto_B.replaceAll("  "," ");
                    }
                    else
                        break;
                }
                //quitar los espacios en blanco al inicio
                while(true){
                    if(texto_B.startsWith(" ")==true){
                        texto_B=texto_B.substring(1);
                    }
                    else
                        break;
                }
                //quitar los espacios en blanco al final
                while(true){
                    if(texto_B.endsWith(" ")==true){
                        texto_B=texto_B.substring(0,texto_B.length()-1);
                    }
                    else
                        break;
                }

                String[] temp_arreglo_B = texto_B.split(" ");

                LinkedList<Integer> temp_lista_B = new LinkedList<Integer>();
                try{
                    for(int i=0;i<temp_arreglo_B.length;i++){
                        temp_lista_B.add(Integer.parseInt(temp_arreglo_B[i]));
                    }
                    ordenar_lista(temp_lista_B);
                }catch(Exception exp){
                    System.out.println("Lo siento.. ingresó mal el conjunto B");
                    hacer=-1;
                    break;
                }

                //Quitar repetidos
                for(int i=0;i<temp_lista_B.size()-1;i++){
                    if(temp_lista_B.get(i).equals(temp_lista_B.get(i+1))){
                        temp_lista_B.remove(i--);
                    }
                }
                
                //System.out.println("tamaño que A: "+temp_lista_A.size()); //debuguear
                //System.out.println("tamaño que B: "+temp_lista_B.size()); //debuguear


                A = new Conjunto<Integer>(temp_lista_A);
                B = new Conjunto<Integer>(temp_lista_B);

                imprimir = A.toString();
                System.out.println("\t ** Conjunto A: "+imprimir);
                imprimir = B.toString();
                System.out.println("\t ** Conjunto B: "+imprimir);

                break;
            case 2://  ********* 2- Ver conjunto A ****************************************************
                //System.out.println("Ver conjunto A");

                imprimir = A.toString();
                System.out.println("\t ** Conjunto A: "+imprimir);
                break;
            case 3://  ********* 3- Ver conjunto B ****************************************************
                //System.out.println("Ver conjunto B");

                imprimir = B.toString();
                System.out.println("\t ** Conjunto B: "+imprimir);
                break;
            case 4://  ********* 4- Agregar/Quitar del conjunto A *************************************

                System.out.println("------------------\n\t¿Qué desea hacer?\n1- Agregar\n2- Quitar\n------------------");
                int numero_presionado=0;
                try{

                    numero_presionado = scan.nextInt();

                }catch(Exception exp){
                    System.out.println("Lo siento... Ingresó mal el número");
                    hacer=-1;
                    break;
                }
                if(numero_presionado==1){
                    //Agregar a A
                    System.out.println("\nIngrese un elemento para el conjunto A");
                    Integer Agregar_A = scan.nextInt();
                    LinkedList<Integer> temp = A.getLista_conjunto();

                    if(A.Lista_conjunto.indexOf(Agregar_A)!=-1){
                        //ya se encuentra porque lo encontró en la lista del conjunto
                        System.out.println("Lo siento, el elemento que ingresó ya se encuentra en el conjunto A");
                    }
                    else{
                        //no se encuentra y lo agrega porque no se había encontrado en la lista del conjunto
                        temp.add(Agregar_A);
                        ordenar_lista(temp);
                        A = new Conjunto<Integer>(temp);
                    }

                    imprimir = A.toString();
                    System.out.println("\t ** Conjunto A: "+imprimir);

                }
                else if(numero_presionado==2){
                    //Quitar elemento de A
                    //Agregar a A
                    System.out.println("\nIngrese el elemento a quitar del conjunto A");
                    Integer Agregar_A = scan.nextInt();
                    LinkedList<Integer> temp = A.getLista_conjunto();

                    if(A.Lista_conjunto.indexOf(Agregar_A)!=-1){
                        //ya se encuentra porque lo encontró en la lista del conjunto
                        temp.remove(Agregar_A);
                        ordenar_lista(temp);
                        A = new Conjunto<Integer>(temp);
                    }
                    else{
                        //no se encuentra y lo agrega porque no se había encontrado en la lista del conjunto
                        System.out.println("Lo siento, el elemento que ingresó no se encuentra en el conjunto A");

                    }

                    imprimir = A.toString();
                    System.out.println("\t ** Conjunto A: "+imprimir);
                }
                else{
                    System.out.println("Lo siento, marcó un número inválido");
                }


                break;
            case 5://  ********* 5- Agregar/Quitar del conjunto B *************************************

                System.out.println("------------------\n\t¿Qué desea hacer?\n1- Agregar\n2- Quitar\n------------------");
                int numero_presionado_B=0;
                try{

                    numero_presionado_B = scan.nextInt();

                }catch(Exception exp){
                    System.out.println("Lo siento... Ingresó mal el número");
                    hacer=-1;
                    break;
                }
                if(numero_presionado_B==1){
                    //Agregar a A
                    System.out.println("\nIngrese un elemento para el conjunto B");
                    Integer Agregar_B = scan.nextInt();
                    LinkedList<Integer> temp_B = B.getLista_conjunto();

                    if(A.Lista_conjunto.indexOf(Agregar_B)!=-1){
                        //ya se encuentra porque lo encontró en la lista del conjunto
                        System.out.println("Lo siento, el elemento que ingresó ya se encuentra en el conjunto B");
                    }
                    else{
                        //no se encuentra y lo agrega porque no se había encontrado en la lista del conjunto
                        temp_B.add(Agregar_B);
                        ordenar_lista(temp_B);
                        B = new Conjunto<Integer>(temp_B);
                    }

                    imprimir = B.toString();
                    System.out.println("\t ** Conjunto B: "+imprimir);

                }
                else if(numero_presionado_B==2){
                    //Quitar elemento de B
                    //Agregar a B
                    System.out.println("\nIngrese el elemento a quitar del conjunto B");
                    Integer Agregar_B = scan.nextInt();
                    LinkedList<Integer> temp_B = B.getLista_conjunto();

                    if(A.Lista_conjunto.indexOf(Agregar_B)!=-1){
                        //ya se encuentra porque lo encontró en la lista del conjunto
                        temp_B.remove(Agregar_B);
                        ordenar_lista(temp_B);
                        A = new Conjunto<Integer>(temp_B);
                    }
                    else{
                        //no se encuentra y lo agrega porque no se había encontrado en la lista del conjunto
                        System.out.println("Lo siento, el elemento que ingresó no se encuentra en el conjunto B");

                    }

                    imprimir = B.toString();
                    System.out.println("\t ** Conjunto B: "+imprimir);
                }
                else{
                    System.out.println("Lo siento, marcó un número inválido");
                }


                break;

            case 6://  ********* 4- Ver A Unión B (unión de los conjuntos A y B) **********************
                //System.out.println("Ver A Unión B (unión de los conjuntos A y B)");

                imprimir = A.toString();
                System.out.println("\t ** Conjunto A: "+imprimir);
                imprimir = B.toString();
                System.out.println("\t ** Conjunto B: "+imprimir);
                
                C = A.Union(B);
                imprimir = C.toString();
                System.out.println("\t ** Conjunto C (A unión B): "+imprimir);

                break;
            case 7://  ********* 5- Ver A Intersección B (intersección de los conjuntos A y B) ********
                //System.out.println("Ver A Intersección B (intersección de los conjuntos A y B)");


                imprimir = A.toString();
                System.out.println("\t ** Conjunto A: "+imprimir);
                imprimir = B.toString();
                System.out.println("\t ** Conjunto B: "+imprimir);

                C = A.Interseccion(B);
                imprimir = C.toString();
                System.out.println("\t ** Conjunto C (A intersección B): "+imprimir);

                break;
        }
    }

    public static void ordenar_lista(LinkedList<Integer> a_ordenar){
        Integer[] temporal_arreglo = new Integer[a_ordenar.size()];
        for(int i=0;i<a_ordenar.size();i++){
            temporal_arreglo[i]=a_ordenar.get(i);
        }
        Sorting.insertionSort(temporal_arreglo);

        a_ordenar.clear();

        for(int i=0;i<temporal_arreglo.length;i++){
            a_ordenar.add(temporal_arreglo[i]);
        }


    }
}

